home *** CD-ROM | disk | FTP | other *** search
/ Visual Cafe 3 / Visual Cafe 3.ISO / Vcafe / JFC.bin / JScrollPane.java < prev    next >
Text File  |  1998-06-30  |  27KB  |  782 lines
  1. /*
  2.  * @(#)JScrollPane.java    1.45 98/04/07
  3.  *
  4.  * Copyright (c) 1997 Sun Microsystems, Inc. All Rights Reserved.
  5.  *
  6.  * This software is the confidential and proprietary information of Sun
  7.  * Microsystems, Inc. ("Confidential Information").  You shall not
  8.  * disclose such Confidential Information and shall use it only in
  9.  * accordance with the terms of the license agreement you entered into
  10.  * with Sun.
  11.  *
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
  13.  * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  14.  * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  15.  * PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
  16.  * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
  17.  * THIS SOFTWARE OR ITS DERIVATIVES.
  18.  *
  19.  */
  20.  
  21. package com.sun.java.swing;
  22.  
  23. import com.sun.java.swing.plaf.*;
  24. import com.sun.java.swing.border.*;
  25. import com.sun.java.accessibility.*;
  26.  
  27. import java.awt.Component;
  28. import java.awt.Graphics;
  29. import java.awt.Rectangle;
  30. import java.awt.Color;
  31.  
  32. import com.sun.java.swing.event.ChangeListener;
  33. import com.sun.java.swing.event.ChangeEvent;
  34.  
  35. /**
  36.  * A specialized container that manages a viewport, optional
  37.  * vertical and horizontal scrollbars, and optional row and
  38.  * column heading viewports.
  39.  * <p>
  40.  * <TABLE ALIGN="RIGHT" BORDER="0">
  41.  *    <TR>
  42.  *    <TD ALIGN="CENTER">
  43.  *      <P ALIGN="CENTER"><IMG SRC="doc-files/JScrollPane-1.gif" WIDTH="256" HEIGHT="248" ALIGN="BOTTOM" BORDER="0">
  44.  *    </TD>
  45.  *    </TR>
  46.  * </TABLE>
  47.  * The JViewPort provides a window, or "viewport" onto a data 
  48.  * source -- for example, a text file. That data source is the 
  49.  * "scrollable client" (aka data model) displayed by the 
  50.  * JViewport view. A JScrollPane basically consists of JScrollBars, a JViewport, 
  51.  * and the wiring between them, as shown in the diagram at right. 
  52.  * <p>
  53.  * In addition to the scroll bars and viewport, a JScrollPane can have a
  54.  * column header and a row header. Each of these is a JViewport object that
  55.  * you specify with <code>setRowHeaderView</code>, and <code>setColumnHeaderView</code>.
  56.  * The column header viewport automatically scrolls left and right, tracking
  57.  * the left-right scrolling of the main viewport. (It never scrolls vertically,
  58.  * however.) The row header acts in a similar fashion.
  59.  * <p>
  60.  * By default, the corners are empty. You can put a component into a corner using 
  61.  * <code>setCorner</code>, in case you there is some function or decoration you
  62.  * would like to add to the scroll pane. The size of corner components is
  63.  * entirely determined by the size of the headers and scroll bars that surround them.
  64.  * <p>
  65.  * To add a border around the main viewport, you can use <code>setViewportBorder</code>. 
  66.  * (Of course, you can also add a border around the whole scroll pane using
  67.  * <code>setBorder</code>.)
  68.  * <p>
  69.  * For the keyboard keys used by this component in the standard Look and
  70.  * Feel (L&F) renditions, see the
  71.  * <a href="doc-files/Key-Index.html#JScrollPane">JScrollPane</a> 
  72.  * key assignments.
  73.  * <p>
  74.  * Warning: serialized objects of this class will not be compatible with
  75.  * future swing releases.  The current serialization support is appropriate
  76.  * for short term storage or RMI between Swing1.0 applications.  It will
  77.  * not be possible to load serialized Swing1.0 objects with future releases
  78.  * of Swing.  The JDK1.2 release of Swing will be the compatibility
  79.  * baseline for the serialized form of Swing objects.
  80.  *
  81.  * @see JScrollBar
  82.  * @see JViewport
  83.  * @see #setRowHeaderView
  84.  * @see #setColumnHeaderView
  85.  * @see #setCorner
  86.  * @see #setViewportBorder
  87.  * @beaninfo
  88.  *      attribute: isContainer true
  89.  *    description: A specialized container that manages a viewport, optional scrollbars and headings
  90.  *
  91.  * @version 1.45 04/07/98
  92.  * @author Hans Muller
  93.  */
  94. public class JScrollPane extends JComponent implements ScrollPaneConstants, Accessible
  95. {
  96.     /** An array of constants that specify the corners */
  97.     protected final static String[] cornerKeywords = {
  98.         LOWER_LEFT_CORNER,
  99.         LOWER_RIGHT_CORNER,
  100.         UPPER_LEFT_CORNER,
  101.         UPPER_RIGHT_CORNER
  102.     };
  103.  
  104.     private Border viewportBorder;
  105.  
  106.     /**
  107.      * Create a JScrollPane that displays the contents of the specified
  108.      * component using the specified scrollbar policies. The scrollbar
  109.      * policies determine the circumstances under which the scrollbars
  110.      * are displayed:<ul>
  111.      * <li>ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED
  112.      * <li>ScrollPaneConstants.VERTICAL_SCROLLBAR_NEVER
  113.      * <li>ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS
  114.      * <li>ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED
  115.      * <li>ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER
  116.      * <li>ScrollPaneConstants.HORIZONTAL_SCROLLBAR_ALWAYS
  117.      * </ul>
  118.      * @param view      the Component to display
  119.      * @param vsbPolicy an int specifying the vertical scrollbar policy
  120.      * @param hsbPolicy an int specifying the horizontal scrollbar policy
  121.      */
  122.     public JScrollPane(Component view, int vsbPolicy, int hsbPolicy) {
  123.  
  124.         /* The set methods that follow all delegate to the ScrollPaneUI
  125.          * object, so we initialize that first.
  126.          */
  127.         updateUI();
  128.  
  129.         setViewport(createViewport());
  130.         setViewportView(view);
  131.         setVerticalScrollBarPolicy(vsbPolicy);
  132.         setHorizontalScrollBarPolicy(hsbPolicy);
  133.     }
  134.  
  135.  
  136.     /**
  137.      * Create a JScrollPane that displays the contents of the specified
  138.      * component, where both horizontal and vertical scrollbars appear
  139.      * whenever the component's contents are larger than the view.
  140.      * 
  141.      * @param view      the Component to display
  142.      */
  143.     public JScrollPane(Component view) {
  144.         this(view, VERTICAL_SCROLLBAR_AS_NEEDED, HORIZONTAL_SCROLLBAR_AS_NEEDED);
  145.     }
  146.  
  147.     /**
  148.      * Create an empty JScrollPane with specified scrollbar policies.
  149.      * The scrollbar policies determine the circumstances under which the 
  150.      * scrollbars are displayed:<ul>
  151.      * <li>ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED
  152.      * <li>ScrollPaneConstants.VERTICAL_SCROLLBAR_NEVER
  153.      * <li>ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS
  154.      * <li>ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED
  155.      * <li>ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER
  156.      * <li>ScrollPaneConstants.HORIZONTAL_SCROLLBAR_ALWAYS
  157.      * </ul>
  158.      * </ul>
  159.      * @param vsbPolicy an int specifying the vertical scrollbar policy
  160.      * @param hsbPolicy an int specifying the horizontal scrollbar policy
  161.      */
  162.     public JScrollPane(int vsbPolicy, int hsbPolicy) {
  163.         this(null, vsbPolicy, hsbPolicy);
  164.     }
  165.  
  166.     /**
  167.      * Create an empty JScrollPane where both horizontal and vertical 
  168.      * scrollbars appear when needed.
  169.      */
  170.     public JScrollPane() {
  171.         this(null, VERTICAL_SCROLLBAR_AS_NEEDED, HORIZONTAL_SCROLLBAR_AS_NEEDED);
  172.     }
  173.  
  174.  
  175.     /**
  176.      * Returns the L&F object that renders this component.
  177.      *
  178.      * @return the ScrollPaneUI object that renders this component
  179.      */
  180.     public ScrollPaneUI getUI() {
  181.         return (ScrollPaneUI)ui;
  182.     }
  183.  
  184.     /**
  185.      * Sets the L&F object that renders this component.
  186.      *
  187.      * @param ui  the ScrollPaneUI L&F object
  188.      * @see UIDefaults#getUI
  189.      */
  190.     public void setUI(ScrollPaneUI ui) {
  191.         super.setUI(ui);
  192.     }
  193.  
  194.  
  195.     /**
  196.      * Notification from the UIManager that the L&F has changed. 
  197.      * Replaces the current UI object with the latest version from the 
  198.      * UIManager.
  199.      *
  200.      * @see JComponent#updateUI
  201.      */
  202.     public void updateUI()
  203.     {
  204.         // PENDING(hmuller) this mess should go away; bound properties.
  205.  
  206.         /* The following properties are managed by the UI object.  Since the'll
  207.          * disappear when we replace the UI object we cache them here.  Note
  208.          * that one might set the UI to null and then later set it to a valid
  209.          * UI object, so we have to stash the property values until the UI
  210.          * is set to a non-null value.
  211.          */
  212.  
  213.         if (ui != null) {
  214.             JViewport viewport = getViewport();
  215.             JViewport rowHeader = getRowHeader();
  216.             JViewport columnHeader = getColumnHeader();
  217.  
  218.             if (viewport != null) putClientProperty(VIEWPORT, viewport);
  219.             if (rowHeader != null) putClientProperty(ROW_HEADER, rowHeader);
  220.             if (columnHeader != null) putClientProperty(COLUMN_HEADER, columnHeader);
  221.  
  222.             Integer vsbPolicy = new Integer(getVerticalScrollBarPolicy());
  223.             Integer hsbPolicy = new Integer(getHorizontalScrollBarPolicy());
  224.             putClientProperty(VERTICAL_SCROLLBAR_POLICY, vsbPolicy);
  225.             putClientProperty(HORIZONTAL_SCROLLBAR_POLICY, hsbPolicy);
  226.  
  227.             for(int i = 0; i < cornerKeywords.length; i++) {
  228.                 Component corner = getCorner(cornerKeywords[i]);
  229.                 if (corner != null) putClientProperty(cornerKeywords[i], corner);
  230.             }
  231.         }
  232.  
  233.         /* Reset the ScrollPaneUI property.
  234.          */
  235.  
  236.         setUI((ScrollPaneUI)UIManager.getUI(this));
  237.  
  238.         /* Restored the non-null cached values for the ScrollPaneUI
  239.          * properties.
  240.          */
  241.  
  242.         if (ui != null) {
  243.             JViewport viewport = (JViewport)getClientProperty(VIEWPORT);
  244.             JViewport rowHeader = (JViewport)getClientProperty(ROW_HEADER);
  245.             JViewport columnHeader = (JViewport)getClientProperty(COLUMN_HEADER);
  246.             Integer vsbPolicy = (Integer)getClientProperty(VERTICAL_SCROLLBAR_POLICY);
  247.             Integer hsbPolicy = (Integer)getClientProperty(HORIZONTAL_SCROLLBAR_POLICY);
  248.  
  249.             if (vsbPolicy != null) { setVerticalScrollBarPolicy(vsbPolicy.intValue()); }
  250.             if (hsbPolicy != null) { setHorizontalScrollBarPolicy(hsbPolicy.intValue()); }
  251.             if (viewport != null) { setViewport(viewport); }
  252.             if (rowHeader != null) { setRowHeader(rowHeader); }
  253.             if (columnHeader != null) { setColumnHeader(columnHeader); }
  254.  
  255.             for(int i = 0; i < cornerKeywords.length; i++) {
  256.                 Component corner = (Component)getClientProperty(cornerKeywords[i]);
  257.                 if (corner != null) {
  258.                     setCorner(cornerKeywords[i], corner);
  259.                 } else {
  260.                     // PENDING(klobad) verify with Hans for this solution
  261.                     setCorner(cornerKeywords[i], new JPanel() {
  262.                         public void paint(Graphics g) {
  263.                             Color controlColor = UIManager.getColor("control");
  264.                             g.setColor(controlColor);
  265.                             g.fillRect(0, 0, _bounds.width, _bounds.height);
  266.                         }
  267.                         public boolean isOpaque() { return true; }
  268.                 });
  269.  
  270.                 }
  271.             }
  272.         }
  273.     }
  274.  
  275.  
  276.     /**
  277.      * Returns the name of the L&F class that renders this component.
  278.      *
  279.      * @return "ScrollPaneUI"
  280.      * @see JComponent#getUIClassID
  281.      * @see UIDefaults#getUI
  282.      */
  283.     public String getUIClassID() {
  284.         return "ScrollPaneUI";
  285.     }
  286.  
  287.     /**
  288.      * Returns the vertical scrollbar policy.
  289.      *
  290.      * @return an int giving the policy
  291.      * @see #setVerticalScrollBarPolicy
  292.      */
  293.     public int getVerticalScrollBarPolicy() {
  294.         return getUI().getVerticalScrollBarPolicy();
  295.     }
  296.  
  297.     /*
  298.      * Determines when the vertical scrollbar appears in the scrollpane, where
  299.      * the options are:<ul>
  300.      * <li>ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED
  301.      * <li>ScrollPaneConstants.VERTICAL_SCROLLBAR_NEVER
  302.      * <li>ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS
  303.      * </ul>
  304.      *
  305.      * @beaninfo
  306.      *   preferred: true
  307.      * description: The scrollpane scrollbar policy
  308.      *        enum: VERTICAL_SCROLLBAR_AS_NEEDED JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED
  309.      *              VERTICAL_SCROLLBAR_NEVER JScrollPane.VERTICAL_SCROLLBAR_NEVER
  310.      *              VERTICAL_SCROLLBAR_ALWAYS JScrollPane.VERTICAL_SCROLLBAR_ALWAYS
  311.      */
  312.     public void setVerticalScrollBarPolicy(int x) {
  313.         if (x != getVerticalScrollBarPolicy()) {
  314.             getUI().setVerticalScrollBarPolicy(x);
  315.             invalidate();
  316.         }
  317.     }
  318.  
  319.     /**
  320.      * Returns the horizontal scrollbar policy.
  321.      *
  322.      * @return an int giving the policy
  323.      * @see #setHorizontalScrollBarPolicy
  324.      */
  325.     public int getHorizontalScrollBarPolicy() {
  326.         return getUI().getHorizontalScrollBarPolicy();
  327.     }
  328.  
  329.     /*
  330.      * Determines when the horizontal scrollbar appears in the scrollpane, where 
  331.      * the options are:<ul>
  332.      * <li>ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED
  333.      * <li>ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER
  334.      * <li>ScrollPaneConstants.HORIZONTAL_SCROLLBAR_ALWAYS
  335.      * </ul>
  336.      *
  337.      * @beaninfo
  338.      *   preferred: true
  339.      * description: The scrollpane scrollbar policy
  340.      *        enum: HORIZONTAL_SCROLLBAR_AS_NEEDED JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED
  341.      *              HORIZONTAL_SCROLLBAR_NEVER JScrollPane.HORIZONTAL_SCROLLBAR_NEVER
  342.      *              HORIZONTAL_SCROLLBAR_ALWAYS JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS
  343.      */
  344.     public void setHorizontalScrollBarPolicy(int x) {
  345.         if (x != getHorizontalScrollBarPolicy()) {
  346.             getUI().setHorizontalScrollBarPolicy(x);
  347.             invalidate();
  348.         }
  349.     }
  350.  
  351.  
  352.     /**
  353.      * Returns the value of the viewportBorder property.
  354.      *
  355.      * @return the Border object that surrounds the viewport
  356.      * @see #setViewportBorder
  357.      */
  358.     public Border getViewportBorder() {
  359.         return viewportBorder;
  360.     }
  361.  
  362.  
  363.     /**
  364.      * Add a border around the viewport.  Note that the border isn't
  365.      * set on the viewport directly, JViewport doesn't support the
  366.      * JComponent border property.  Similarly setting the JScrollPanes
  367.      * viewport doesn't effect the viewportBorder property.
  368.      * <p>
  369.      * The default value of this property is computed by the look
  370.      * and feel implementation.
  371.      * <p>
  372.      * This is a JavaBeans bound property.
  373.      *
  374.      * @see #getViewportBorder
  375.      * @see #setViewport
  376.      *
  377.      * @beaninfo
  378.      *   preferred: true
  379.      *       bound: true
  380.      * description: The border around the viewport.
  381.      */
  382.     public void setViewportBorder(Border viewportBorder) {
  383.         Border oldValue = this.viewportBorder;
  384.         this.viewportBorder = viewportBorder;
  385.         firePropertyChange("viewportBorder", oldValue, viewportBorder);
  386.     }
  387.  
  388.  
  389.     /**
  390.      * By default JScrollPane creates scrollbars that are instances
  391.      * of this class.  Scrollbar overrides the getUnitIncrement
  392.      * and getBlockIncrement methods so that, if the viewports view is 
  393.      * a Scrollable, the view is asked to compute these values.
  394.      * <p>
  395.      * Warning: serialized objects of this class will not be compatible with
  396.      * future swing releases.  The current serialization support is appropriate
  397.      * for short term storage or RMI between Swing1.0 applications.  It will
  398.      * not be possible to load serialized Swing1.0 objects with future releases
  399.      * of Swing.  The JDK1.2 release of Swing will be the compatibility
  400.      * baseline for the serialized form of Swing objects.
  401.      *
  402.      * @see Scrollable
  403.      * @see JScrollPane#createVerticalScrollBar
  404.      * @see JScrollPane#createHorizontalScrollBar
  405.      */
  406.     protected class ScrollBar extends JScrollBar
  407.     {
  408.         /**
  409.          * Create a scrollbar with the specified orientation, where the options
  410.          * are:<ul>
  411.          * <li>ScrollPaneConstants.VERTICAL_SCROLLBAR
  412.          * <li>ScrollPaneConstants.HORIZONTAL_SCROLLBAR
  413.          * </ul>
  414.          *
  415.          * @param orientation  an int specifying the orientation
  416.          */
  417.         public ScrollBar(int orientation) {
  418.             super(orientation);
  419.         }
  420.  
  421.         /**
  422.          * If the viewports view is a Scrollable then ask the view
  423.          * to compute the unit increment.  Otherwise return
  424.          * super.getUnitIncrement().
  425.          * 
  426.          * @see Scrollable#getScrollableUnitIncrement
  427.          */
  428.         public int getUnitIncrement(int direction) {
  429.             JViewport vp = getViewport();
  430.             if ((vp != null) && (vp.getView() instanceof Scrollable)) {
  431.                 Scrollable view = (Scrollable)(vp.getView());
  432.                 Rectangle vr = vp.getViewRect();
  433.                 return view.getScrollableUnitIncrement(vr, getOrientation(), direction);
  434.             }
  435.             else {
  436.                 return super.getUnitIncrement(direction);
  437.             }
  438.         }
  439.  
  440.         /**
  441.          * If the viewports view is a Scrollable then ask the
  442.          * view to compute the block increment.  Otherwise
  443.          * the blockIncrement equals the viewports width
  444.          * or height.  If there's no viewport reuurn 
  445.          * super.getBlockIncrement().
  446.          * 
  447.          * @see Scrollable#getScrollableBlockIncrement
  448.          */
  449.         public int getBlockIncrement(int direction) {
  450.             JViewport vp = getViewport();
  451.             if (vp == null) {
  452.                 return super.getBlockIncrement(direction);
  453.             }
  454.             else if (vp.getView() instanceof Scrollable) {
  455.                 Scrollable view = (Scrollable)(vp.getView());
  456.                 Rectangle vr = vp.getViewRect();
  457.                 return view.getScrollableBlockIncrement(vr, getOrientation(), direction);
  458.             }
  459.             else if (getOrientation() == VERTICAL) {
  460.                 return vp.getExtentSize().width;
  461.             }
  462.             else {
  463.                 return vp.getExtentSize().height;
  464.             }
  465.         }
  466.     }
  467.  
  468.  
  469.     /**
  470.      * Used by ScrollPaneUI implementations to create the horizontal
  471.      * scrollbar.  Returns a JScrollPane.ScrollBar by default.  Subclasses
  472.      * may override this method to force ScrollPaneUI implementations to
  473.      * use a JScrollBar subclass.
  474.      *
  475.      * @return a JScrollBar with a horizontal orientation
  476.      * @see JScrollBar
  477.      */
  478.     public JScrollBar createHorizontalScrollBar() {
  479.         return new ScrollBar(JScrollBar.HORIZONTAL);
  480.     }
  481.  
  482.     /**
  483.      * Used by ScrollPaneUI implementations to create the vertical
  484.      * scrollbar.  Returns a JScrollPane.ScrollBar by default.  Subclasses
  485.      * may override this method to force ScrollPaneUI implementations to
  486.      * use a JScrollBar subclass.
  487.      *
  488.      * @return a JScrollBar with a vertical orientation
  489.      * @see JScrollBar
  490.      */
  491.     public JScrollBar createVerticalScrollBar() {
  492.         return new ScrollBar(JScrollBar.VERTICAL);
  493.     }
  494.  
  495.     /**
  496.      * Returns the horizontal scroll bar currently in use.
  497.      *
  498.      * @return the JScrollBar currently used for horizontal scrolling
  499.      * @see ScrollBar
  500.      */
  501.     public JScrollBar getHorizontalScrollBar() {
  502.         return getUI().getHorizontalScrollBar();
  503.     }
  504.  
  505.     /**
  506.      * Returns the vertical scroll bar currently in use.
  507.      *
  508.      * @return the JScrollBar currently used for vertical scrolling
  509.      * @see ScrollBar
  510.      */
  511.     public JScrollBar getVerticalScrollBar() {
  512.         return getUI().getVerticalScrollBar();
  513.     }
  514.  
  515.     /**
  516.      * Returns a new JViewport by default.  Used to create the
  517.      * viewport (as needed) in <code>setViewportView</code>,
  518.      * <code>setRowHeaderView</code>, and <code>setColumnHeaderView</code>.
  519.      * Subclasses may override this method to return a subclass of JViewport.
  520.      *
  521.      * @return a JViewport
  522.      */
  523.     protected JViewport createViewport() {
  524.         return new JViewport();
  525.     }
  526.  
  527.     /**
  528.      * Returns the current JViewport.
  529.      *
  530.      * @return the JViewport currently in use
  531.      */
  532.     public JViewport getViewport() {
  533.         return getUI().getViewport();
  534.     }
  535.  
  536.     /**
  537.      * Sets the current JViewport.
  538.      *
  539.      * @return the JViewport to use
  540.      */
  541.     public void setViewport(JViewport x) {
  542.         if (x != getViewport()) {
  543.             getUI().setViewport(x);
  544.             invalidate();
  545.             if (accessibleContext != null) {
  546.                 ((AccessibleJScrollPane)accessibleContext).resetViewPort();
  547.             }
  548.         }
  549.     }
  550.  
  551.     /**
  552.      * Creates a viewport if neccessary and then sets its view.
  553.      *
  554.      * @param view the Component to view
  555.      */
  556.     public void setViewportView(Component view) {
  557.         if (getViewport() == null) {
  558.             setViewport(createViewport());
  559.         }
  560.         getViewport().setView(view);
  561.     }
  562.  
  563.  
  564.     /**
  565.      * Returns the row-header viewport.
  566.      *
  567.      * @return the JViewport for the row header
  568.      */
  569.     public JViewport getRowHeader() {
  570.         return getUI().getRowHeader();
  571.     }
  572.  
  573.     /**
  574.      * Sets a row-header viewport.
  575.      *
  576.      * @param x the JViewport to use for a row header
  577.      * @beaninfo
  578.      *   preferred: true
  579.      * description: The header viewport.
  580.      */
  581.     public void setRowHeader(JViewport x) {
  582.         if (x != getRowHeader()) {
  583.             getUI().setRowHeader(x);
  584.             invalidate();
  585.         }
  586.     }
  587.  
  588.     /**
  589.      * Creates a row-header viewport if neccessary and then sets
  590.      * its view.
  591.      *
  592.      * @param view the Component to display as the row header
  593.      */
  594.     public void setRowHeaderView(Component view) {
  595.         if (getRowHeader() == null) {
  596.             setRowHeader(createViewport());
  597.         }
  598.         getRowHeader().setView(view);
  599.     }
  600.  
  601.  
  602.     /**
  603.      * Returns the column-header viewport.
  604.      *
  605.      * @return the JViewport for the column header
  606.      */
  607.     public JViewport getColumnHeader() {
  608.         return getUI().getColumnHeader();
  609.     }
  610.  
  611.     /**
  612.      * Sets a column-header viewport
  613.      *
  614.      * @param x  the JViewport to use for the column header
  615.      * @beaninfo
  616.      *   preferred: true
  617.      * description: The column viewport.
  618.      */
  619.     public void setColumnHeader(JViewport x) {
  620.         if (x != getColumnHeader()) {
  621.             getUI().setColumnHeader(x);
  622.             invalidate();
  623.         }
  624.     }
  625.  
  626.     /**
  627.      * Creates a column-header viewport if neccessary and then sets
  628.      * its view.
  629.      *
  630.      * @param view the Component to display as the column header
  631.      */
  632.     public void setColumnHeaderView(Component view) {
  633.         if (getColumnHeader() == null) {
  634.             setColumnHeader(createViewport());
  635.         }
  636.         getColumnHeader().setView(view);
  637.     }
  638.  
  639.  
  640.     /**
  641.      * Returns the _________________,
  642.      * where the options for the key are:<ul>
  643.      * <li>ScrollPaneConstants.LOWER_LEFT_CORNER
  644.      * <li>ScrollPaneConstants.LOWER_RIGHT_CORNER
  645.      * <li>ScrollPaneConstants.UPPER_LEFT_CORNER
  646.      * <li>ScrollPaneConstants.UPPER_RIGHT_CORNER
  647.      * </ul>
  648.      * @param key  a String specifying the corner
  649.      * @return the Component _________________
  650.      */
  651.     public Component getCorner(String key) {
  652.         return getUI().getCorner(key);
  653.     }
  654.  
  655.     /**
  656.      * Sets the _________________,
  657.      * where the options for the key are:<ul>
  658.      * <li>ScrollPaneConstants.LOWER_LEFT_CORNER
  659.      * <li>ScrollPaneConstants.LOWER_RIGHT_CORNER
  660.      * <li>ScrollPaneConstants.UPPER_LEFT_CORNER
  661.      * <li>ScrollPaneConstants.UPPER_RIGHT_CORNER
  662.      * </ul>
  663.      * @param key  a String specifying the corner
  664.      * @param x    the Component _________________
  665.      */
  666.     public void setCorner(String key, Component x) {
  667.         if (x != getCorner(key)) {
  668.             getUI().setCorner(key, x);
  669.             invalidate();
  670.         }
  671.     }
  672.  
  673.  
  674.     /**
  675.      * Returns true if this component paints every pixel
  676.      * in its range. (In other words, it does not have a transparent
  677.      * background or foreground.)
  678.      *
  679.      * @return The value of the opaque property
  680.      * @see JComponent#isOpaque
  681.      */
  682.     public boolean isOpaque() {
  683.         JViewport viewport;
  684.         Component view;
  685.         if( (viewport = getViewport()) != null    && 
  686.             ((view = viewport.getView()) != null) &&
  687.             ((view instanceof JComponent) && ((JComponent)view).isOpaque())) {
  688.             if(((JComponent)view).getWidth()  >= viewport.getWidth() && 
  689.                ((JComponent)view).getHeight() >= viewport.getHeight())
  690.                 return true;
  691.         }
  692.         return false;
  693.     }
  694.  
  695.  
  696.     /** 
  697.      * Calls to revalidate() any descendant of this JScrollPane, e.g. 
  698.      * the viewports view, will cause a request to be queued that
  699.      * will validate this JScrollPane and all its descendants.
  700.      * 
  701.      * @return true
  702.      * @see revalidate
  703.      * @see java.awt.Component#invalidate
  704.      * @see java.awt.Container#validate
  705.      */
  706.     public boolean isValidateRoot() {
  707.         return true;
  708.     }
  709.  
  710.  
  711. /////////////////
  712. // Accessibility support
  713. ////////////////
  714.  
  715.     /**
  716.      * Get the AccessibleContext associated with this JComponent
  717.      *
  718.      * @return the AccessibleContext of this JComponent
  719.      */
  720.     public AccessibleContext getAccessibleContext() {
  721.         if (accessibleContext == null) {
  722.             accessibleContext = new AccessibleJScrollPane();
  723.         }
  724.         return accessibleContext;
  725.     }
  726.  
  727.     /**
  728.      * The class used to obtain the accessible role for this object.
  729.      * <p>
  730.      * Warning: serialized objects of this class will not be compatible with
  731.      * future swing releases.  The current serialization support is appropriate
  732.      * for short term storage or RMI between Swing1.0 applications.  It will
  733.      * not be possible to load serialized Swing1.0 objects with future releases
  734.      * of Swing.  The JDK1.2 release of Swing will be the compatibility
  735.      * baseline for the serialized form of Swing objects.
  736.      */
  737.     protected class AccessibleJScrollPane extends AccessibleJComponent 
  738.     implements ChangeListener {
  739.  
  740.         protected JViewport viewPort = null;
  741.  
  742.         public void resetViewPort() {
  743.             viewPort.removeChangeListener(this);
  744.             viewPort = JScrollPane.this.getViewport();
  745.             viewPort.addChangeListener(this);
  746.         }
  747.  
  748.         /**
  749.          * Constructor to set up listener on viewport.
  750.          */
  751.         public AccessibleJScrollPane() {
  752.             super();
  753.             if (viewPort == null) {
  754.                viewPort = JScrollPane.this.getViewport();
  755.             }
  756.             viewPort.addChangeListener(this);
  757.         }
  758.  
  759.         /**
  760.          * Get the role of this object.
  761.          *
  762.          * @return an instance of AccessibleRole describing the role of the 
  763.          * object
  764.          * @see AccessibleRole
  765.          */
  766.         public AccessibleRole getAccessibleRole() {
  767.             return AccessibleRole.SCROLL_PANE;
  768.         }
  769.  
  770.         /**
  771.          * Supports the change listener interface and fires property change
  772.          */
  773.         public void stateChanged(ChangeEvent e) {
  774.             AccessibleContext ac = ((Accessible)JScrollPane.this).getAccessibleContext();
  775.             if (ac != null) {
  776.                 ac.firePropertyChange(AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY, new Boolean(false), new Boolean(true));
  777.             }
  778.         }
  779.     }
  780. }
  781.  
  782.